#ifndef __M_SERVER_H__
#define __M_SERVER_H__
#include <iostream>
#include <vector>
#include <string>
#include <cassert>
#include <cstring>
#include <ctime>
#include <functional>
#include <unordered_map>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <memory>
#include <typeinfo>
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <sys/eventfd.h>
#include <sys/timerfd.h>

#define INF 0
#define DBG 1
#define ERR 2
#define LOG_LEVEL DBG

#include <fstream>
#include <cstdarg>
#include <sys/types.h>

#include <iostream>
#include <fstream>
#include <string>
#include <mutex>
#include <ctime>
#include <cstdarg>
#include <unistd.h>
#include <sys/types.h>

// 日志信息等级
enum LogLevel {
    DEBUG = 1, // 调试
    INFO,      // 信息输出
    WARNING,   // 警告
    ERROR,     // 错误
    FATAL      // 致命错误
};

// 将日志等级转换为字符串
std::string LevelToString(LogLevel level) {
    switch (level) {
    case DEBUG:
        return "DEBUG";
    case INFO:
        return "INFO";
    case WARNING:
        return "WARNING";
    case ERROR:
        return "ERROR";
    case FATAL:
        return "FATAL";
    default:
        return "UNKNOWN";
    }
}

// 日志消息结构体
struct LogMessage {
    std::string level;
    pid_t pid;
    std::string fileName;
    int fileNumber;
    std::string logInfo;
    std::string currentTime;
};

// 打印选项
const int TO_SCREEN = 1;
const int TO_FILE = 2;
const int TIME_BUFF = 128;
const int INFO_BUFF = 1024;

// 日志类
class Log {
private:
    LogMessage logMessage;
    int printChoice;
    std::string printFileName;
    std::mutex logMutex;
    LogLevel miniErrLevel; // 最低错误等级，只打印等于或高于该错误等级的日志信息

    // 获取当前时间
    std::string getCurrentTime() {
        auto now = std::time(nullptr);
        auto time = std::localtime(&now);
        char timeBuff[TIME_BUFF];
        std::snprintf(timeBuff, TIME_BUFF, "%d/%02d/%02d %02d:%02d:%02d",
                      time->tm_year + 1900, time->tm_mon + 1,
                      time->tm_mday, time->tm_hour, time->tm_min, time->tm_sec);
        return timeBuff;
    }

    // 创建日志消息
    void createLogMessage(LogLevel level, const std::string& filename, int filenumber, const char* format, va_list args) {
        if (level < miniErrLevel) {
            return; // 过滤低于最低错误等级的日志信息
        }
        logMessage.level = LevelToString(level);
        logMessage.fileName = filename;
        logMessage.fileNumber = filenumber;
        logMessage.pid = getpid();
        logMessage.currentTime = getCurrentTime();

        char infoBuff[INFO_BUFF];
        std::vsnprintf(infoBuff, INFO_BUFF, format, args);
        logMessage.logInfo = infoBuff;

        flushLog(logMessage);
    }

    // 向屏幕打印日志
    void flushLogToScreen(const LogMessage& lg) {
        std::printf("[%s][%d][%s][%d][%s] %s\n",
                    lg.level.c_str(),
                    lg.pid,
                    lg.fileName.c_str(),
                    lg.fileNumber,
                    lg.currentTime.c_str(),
                    lg.logInfo.c_str());
    }

    // 向文件打印日志
    void flushLogToFile(const LogMessage& lg) {
        std::ofstream out(printFileName, std::ios::app);
        if (out.is_open()) {
            char info[INFO_BUFF];
            std::snprintf(info, sizeof(info), "[%s][%d][%s][%d][%s] %s\n",
                          lg.level.c_str(),
                          lg.pid,
                          lg.fileName.c_str(),
                          lg.fileNumber,
                          lg.currentTime.c_str(),
                          lg.logInfo.c_str());
            out.write(info, std::strlen(info));
            out.close();
        }
    }

    // 刷新日志
    void flushLog(const LogMessage& lg) {
        std::lock_guard<std::mutex> lock(logMutex);
        switch (printChoice) {
        case TO_SCREEN:
            flushLogToScreen(lg);
            break;
        case TO_FILE:
            flushLogToFile(lg);
            break;
        }
    }

public:
    // 构造函数
    Log(int printChoice = TO_SCREEN, const std::string& printFileName = "./log.txt", LogLevel minLevel = DEBUG)
        : printChoice(printChoice), printFileName(printFileName), miniErrLevel(minLevel) {}

    // 记录日志
    void log(LogLevel level, const std::string& filename, int filenumber, const char* format, ...) {
        va_list args;
        va_start(args, format);
        createLogMessage(level, filename, filenumber, format, args);
        va_end(args);
    }

    // 改变日志打印路径
    void changePrintChoice(int newChoice) {
        printChoice = newChoice;
    }

    // 设置最低错误等级
    void setMiniErrLevel(LogLevel level) {
        miniErrLevel = level;
    }

    // 启用输出选项
    void enableOutput(int choice) {
        changePrintChoice(choice);
    }
};

// 全局日志对象
Log lg;

// 日志打印宏
#define INF_LOG(format, ...) lg.log(INFO, __FILE__, __LINE__, format, ##__VA_ARGS__)
#define DBG_LOG(format, ...) lg.log(DEBUG, __FILE__, __LINE__, format, ##__VA_ARGS__)
#define ERR_LOG(format, ...) lg.log(ERROR, __FILE__, __LINE__, format, ##__VA_ARGS__)
#define WRN_LOG(format, ...) lg.log(WARNING, __FILE__, __LINE__, format, ##__VA_ARGS__)
#define FTL_LOG(format, ...) lg.log(FATAL, __FILE__, __LINE__, format, ##__VA_ARGS__)
#define EnableScreen() lg.enableOutput(TO_SCREEN)
#define EnableFILE() lg.enableOutput(TO_FILE)


// 定义缓冲区的默认大小
#define BUFFER_DEFAULT_SIZE 1024

// Buffer 类用于管理一个动态大小的缓冲区，支持数据的读写操作
class Buffer {
private:
    // 使用 std::vector 管理缓冲区的内存空间
    std::vector<char> _buffer;
    // 读偏移量，指示当前可读数据的起始位置
    uint64_t _reader_idx;
    // 写偏移量，指示当前可写数据的起始位置
    uint64_t _writer_idx;

    // 确保缓冲区有足够的空间来写入指定长度的数据
    // 如果尾部空闲空间足够，直接返回；若总空闲空间足够，将数据移到起始位置；否则进行扩容
    void _EnsureSufficientWriteSpace(uint64_t len) {
        // 若尾部空闲空间足够，无需额外操作
        if (TailIdleSize() >= len) {
            return;
        }
        // 若总空闲空间（头部空闲 + 尾部空闲）足够，移动数据到起始位置
        if (len <= TailIdleSize() + HeadIdleSize()) {
            // 记录当前可读数据的长度
            uint64_t readable_size = ReadAbleSize();
            // 将可读数据复制到缓冲区起始位置
            std::copy(ReadPosition(), ReadPosition() + readable_size, Begin());
            // 重置读偏移量为 0
            _reader_idx = 0;
            // 更新写偏移量为当前可读数据的长度
            _writer_idx = readable_size;
        } else {
            // 总空闲空间不足，进行扩容操作
            DBG_LOG("RESIZE %ld", _writer_idx + len);
            _buffer.resize(_writer_idx + len);
        }
    }

public:
    // 构造函数，初始化缓冲区、读偏移量和写偏移量
    Buffer() : _reader_idx(0), _writer_idx(0), _buffer(BUFFER_DEFAULT_SIZE) {}

    // 获取缓冲区的起始地址
    char* Begin() {
        return &*_buffer.begin();
    }

    // 获取当前写入的起始地址，即缓冲区起始地址加上写偏移量
    char* WritePosition() {
        return Begin() + _writer_idx;
    }

    // 获取当前读取的起始地址，即缓冲区起始地址加上读偏移量
    char* ReadPosition() {
        return Begin() + _reader_idx;
    }

    // 获取缓冲区末尾的空闲空间大小，即总空间大小减去写偏移量
    uint64_t TailIdleSize() {
        return _buffer.size() - _writer_idx;
    }

    // 获取缓冲区起始的空闲空间大小，即读偏移量的值
    uint64_t HeadIdleSize() {
        return _reader_idx;
    }

    // 获取缓冲区中可读数据的大小，即写偏移量减去读偏移量
    uint64_t ReadAbleSize() {
        return _writer_idx - _reader_idx;
    }

    // 将读偏移量向后移动指定的长度
    // 移动长度需小于等于当前可读数据的大小
    void MoveReadOffset(uint64_t len) {
        if (len == 0) {
            return;
        }
        // 确保移动长度不超过可读数据大小
        assert(len <= ReadAbleSize());
        _reader_idx += len;
    }

    // 将写偏移量向后移动指定的长度
    // 移动长度需小于等于当前尾部的空闲空间大小
    void MoveWriteOffset(uint64_t len) {
        // 确保移动长度不超过尾部空闲空间大小
        assert(len <= TailIdleSize());
        _writer_idx += len;
    }

    // 确保可写空间足够，调用私有函数 _EnsureSufficientWriteSpace 实现
    void EnsureWriteSpace(uint64_t len) {
        _EnsureSufficientWriteSpace(len);
    }

    // 向缓冲区写入指定长度的数据
    // 先确保有足够空间，再将数据复制到写入位置
    void Write(const void* data, uint64_t len) {
        if (len == 0) {
            return;
        }
        // 确保有足够空间写入数据
        EnsureWriteSpace(len);
        const char* d = static_cast<const char*>(data);
        // 将数据复制到写入位置
        std::copy(d, d + len, WritePosition());
    }

    // 写入数据并将写偏移量向后移动相应长度
    void WriteAndPush(const void* data, uint64_t len) {
        Write(data, len);
        MoveWriteOffset(len);
    }

    // 写入字符串数据，将字符串转换为字符指针并调用 Write 函数
    void WriteString(const std::string& data) {
        Write(data.c_str(), data.size());
    }

    // 写入字符串数据并将写偏移量向后移动相应长度
    void WriteStringAndPush(const std::string& data) {
        WriteString(data);
        MoveWriteOffset(data.size());
    }

    // 从另一个缓冲区写入数据，调用 Write 函数
    void WriteBuffer(Buffer& data) {
        Write(data.ReadPosition(), data.ReadAbleSize());
    }

    // 从另一个缓冲区写入数据并将写偏移量向后移动相应长度
    void WriteBufferAndPush(Buffer& data) {
        WriteBuffer(data);
        MoveWriteOffset(data.ReadAbleSize());
    }

    // 从缓冲区读取指定长度的数据到指定位置
    // 读取长度需小于等于当前可读数据的大小
    void Read(void* buf, uint64_t len) {
        // 确保读取长度不超过可读数据大小
        assert(len <= ReadAbleSize());
        // 将数据从读取位置复制到指定位置
        std::copy(ReadPosition(), ReadPosition() + len, static_cast<char*>(buf));
    }

    // 读取数据并将读偏移量向后移动相应长度
    void ReadAndPop(void* buf, uint64_t len) {
        Read(buf, len);
        MoveReadOffset(len);
    }

    // 以字符串形式读取指定长度的数据
    // 读取长度需小于等于当前可读数据的大小
    std::string ReadAsString(uint64_t len) {
        // 确保读取长度不超过可读数据大小
        assert(len <= ReadAbleSize());
        std::string str;
        str.resize(len);
        // 读取数据到字符串
        Read(&str[0], len);
        return str;
    }

    // 以字符串形式读取指定长度的数据并将读偏移量向后移动相应长度
    std::string ReadAsStringAndPop(uint64_t len) {
        assert(len <= ReadAbleSize());
        std::string str = ReadAsString(len);
        MoveReadOffset(len);
        return str;
    }

    // 在可读数据中查找换行符（'\n'）的位置
    char* FindCRLF() {
        return static_cast<char*>(std::memchr(ReadPosition(), '\n', ReadAbleSize()));
    }

    // 获取一行数据，包含换行符
    // 若未找到换行符，返回空字符串
    std::string GetLine() {
        char* pos = FindCRLF();
        if (pos == nullptr) {
            return "";
        }
        // 读取包含换行符的一行数据
        return ReadAsString(pos - ReadPosition() + 1);
    }

    // 获取一行数据并将读偏移量向后移动相应长度
    std::string GetLineAndPop() {
        std::string str = GetLine();
        MoveReadOffset(str.size());
        return str;
    }

    // 清空缓冲区，将读偏移量和写偏移量都置为 0
    void Clear() {
        _reader_idx = 0;
        _writer_idx = 0;
    }
};

#define MAX_LISTEN 1024
class Socket {
    private:
        int _sockfd;
    public:
        Socket():_sockfd(-1) {}
        Socket(int fd): _sockfd(fd) {}
        ~Socket() { Close(); }
        int Fd() { return _sockfd; }
        //创建套接字
        bool Create() {
            // int socket(int domain, int type, int protocol)
            _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
            if (_sockfd < 0) {
                ERR_LOG("CREATE SOCKET FAILED!!");
                return false;
            }
            return true;
        }
        //绑定地址信息
        bool Bind(const std::string &ip, uint16_t port) {
            struct sockaddr_in addr;
            addr.sin_family = AF_INET;
            addr.sin_port = htons(port);
            addr.sin_addr.s_addr = inet_addr(ip.c_str());
            socklen_t len = sizeof(struct sockaddr_in);
            // int bind(int sockfd, struct sockaddr*addr, socklen_t len);
            int ret = bind(_sockfd, (struct sockaddr*)&addr, len);
            if (ret < 0) {
                ERR_LOG("BIND ADDRESS FAILED!");
                return false;
            }
            return true;
        }
        //开始监听
        bool Listen(int backlog = MAX_LISTEN) {
            // int listen(int backlog)
            int ret = listen(_sockfd, backlog);
            if (ret < 0) {
                ERR_LOG("SOCKET LISTEN FAILED!");
                return false;
            }
            return true;
        }
        //向服务器发起连接
        bool Connect(const std::string &ip, uint16_t port) {
            struct sockaddr_in addr;
            addr.sin_family = AF_INET;
            addr.sin_port = htons(port);
            addr.sin_addr.s_addr = inet_addr(ip.c_str());
            socklen_t len = sizeof(struct sockaddr_in);
            // int connect(int sockfd, struct sockaddr*addr, socklen_t len);
            int ret = connect(_sockfd, (struct sockaddr*)&addr, len);
            if (ret < 0) {
                ERR_LOG("CONNECT SERVER FAILED!");
                return false;
            }
            return true;
        }
        //获取新连接
        int Accept() {
            // int accept(int sockfd, struct sockaddr *addr, socklen_t *len);
            int newfd = accept(_sockfd, NULL, NULL);
            if (newfd < 0) {
                ERR_LOG("SOCKET ACCEPT FAILED!");
                return -1;
            }
            return newfd;
        }
        //接收数据
        ssize_t Recv(void *buf, size_t len, int flag = 0) {
            // ssize_t recv(int sockfd, void *buf, size_t len, int flag);
            ssize_t ret = recv(_sockfd, buf, len, flag);
            if (ret <= 0) {
                //EAGAIN 当前socket的接收缓冲区中没有数据了，在非阻塞的情况下才会有这个错误
                //EINTR  表示当前socket的阻塞等待，被信号打断了，
                if (errno == EAGAIN || errno == EINTR) {
                    return 0;//表示这次接收没有接收到数据
                }
                ERR_LOG("SOCKET RECV FAILED!!");
                return -1;
            }
            return ret; //实际接收的数据长度
        }
        ssize_t NonBlockRecv(void *buf, size_t len) {
            return Recv(buf, len, MSG_DONTWAIT); // MSG_DONTWAIT 表示当前接收为非阻塞。
        }
        //发送数据
        ssize_t Send(const void *buf, size_t len, int flag = 0) {
            // ssize_t send(int sockfd, void *data, size_t len, int flag);
            ssize_t ret = send(_sockfd, buf, len, flag);
            if (ret < 0) {
                if (errno == EAGAIN || errno == EINTR) {
                    return 0;
                }
                ERR_LOG("SOCKET SEND FAILED!!");
                return -1;
            }
            return ret;//实际发送的数据长度
        }
        ssize_t NonBlockSend(void *buf, size_t len) {
            if (len == 0) return 0;
            return Send(buf, len, MSG_DONTWAIT); // MSG_DONTWAIT 表示当前发送为非阻塞。
        }
        //关闭套接字
        void Close() {
            if (_sockfd != -1) {
                close(_sockfd);
                _sockfd = -1;
            }
        }
        //创建一个服务端连接
        bool CreateServer(uint16_t port, const std::string &ip = "0.0.0.0", bool block_flag = false) {
            //1. 创建套接字，2. 绑定地址，3. 开始监听，4. 设置非阻塞， 5. 启动地址重用
            if (Create() == false) return false;
            if (block_flag) NonBlock();
            if (Bind(ip, port) == false) return false;
            if (Listen() == false) return false;
            ReuseAddress();
            return true;
        }
        //创建一个客户端连接
        bool CreateClient(uint16_t port, const std::string &ip) {
            //1. 创建套接字，2.指向连接服务器
            if (Create() == false) return false;
            if (Connect(ip, port) == false) return false;
            return true;
        }
        //设置套接字选项---开启地址端口重用
        void ReuseAddress() {
            // int setsockopt(int fd, int leve, int optname, void *val, int vallen)
            int val = 1;
            setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, (void*)&val, sizeof(int));
            val = 1;
            setsockopt(_sockfd, SOL_SOCKET, SO_REUSEPORT, (void*)&val, sizeof(int));
        }
        //设置套接字阻塞属性-- 设置为非阻塞
        void NonBlock() {
            //int fcntl(int fd, int cmd, ... /* arg */ );
            int flag = fcntl(_sockfd, F_GETFL, 0);
            fcntl(_sockfd, F_SETFL, flag | O_NONBLOCK);
        }
};

class Poller;
class EventLoop;
class Channel {
    private:
        int _fd;
        EventLoop *_loop;
        uint32_t _events;  // 当前需要监控的事件
        uint32_t _revents; // 当前连接触发的事件
        using EventCallback = std::function<void()>;
        EventCallback _read_callback;   //可读事件被触发的回调函数
        EventCallback _write_callback;  //可写事件被触发的回调函数
        EventCallback _error_callback;  //错误事件被触发的回调函数
        EventCallback _close_callback;  //连接断开事件被触发的回调函数
        EventCallback _event_callback;  //任意事件被触发的回调函数
    public:
        Channel(EventLoop *loop, int fd):_fd(fd), _events(0), _revents(0), _loop(loop) {}
        int Fd() { return _fd; }
        uint32_t Events() { return _events; }//获取想要监控的事件
        void SetREvents(uint32_t events) { _revents = events; }//设置实际就绪的事件
        void SetReadCallback(const EventCallback &cb) { _read_callback = cb; }
        void SetWriteCallback(const EventCallback &cb) { _write_callback = cb; }
        void SetErrorCallback(const EventCallback &cb) { _error_callback = cb; }
        void SetCloseCallback(const EventCallback &cb) { _close_callback = cb; }
        void SetEventCallback(const EventCallback &cb) { _event_callback = cb; }
        //当前是否监控了可读
        bool ReadAble() { return (_events & EPOLLIN); } 
        //当前是否监控了可写
        bool WriteAble() { return (_events & EPOLLOUT); }
        //启动读事件监控
        void EnableRead() { _events |= EPOLLIN; Update(); }
        //启动写事件监控
        void EnableWrite() { _events |= EPOLLOUT; Update(); }
        //关闭读事件监控
        void DisableRead() { _events &= ~EPOLLIN; Update(); }
        //关闭写事件监控
        void DisableWrite() { _events &= ~EPOLLOUT; Update(); }
        //关闭所有事件监控
        void DisableAll() { _events = 0; Update(); }
        //移除监控
        void Remove();
        void Update();
        //事件处理，一旦连接触发了事件，就调用这个函数，自己触发了什么事件如何处理自己决定
        void HandleEvent() {
            if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI)) {
                /*不管任何事件，都调用的回调函数*/
                if (_read_callback) _read_callback();
            }
            /*有可能会释放连接的操作事件，一次只处理一个*/
            if (_revents & EPOLLOUT) {
                if (_write_callback) _write_callback();
            }else if (_revents & EPOLLERR) {
                if (_error_callback) _error_callback();//一旦出错，就会释放连接，因此要放到前边调用任意回调
            }else if (_revents & EPOLLHUP) {
                if (_close_callback) _close_callback();
            }
            if (_event_callback) _event_callback();
        }
};
// epoll 最大事件数量
#define MAX_EPOLLEVENTS 1024

// Poller 类用于管理 epoll 事件的监听和处理
class Poller {
private:
    // epoll 实例的文件描述符
    int _epoll_fd;
    // 存储 epoll 等待返回的事件数组
    struct epoll_event _epoll_events[MAX_EPOLLEVENTS];
    // 存储文件描述符和对应的 Channel 指针的映射
    std::unordered_map<int, Channel*> _channel_map;

    // 直接操作 epoll_ctl 函数，更新指定 Channel 的事件监听状态
    void _UpdateEpollEvent(Channel* channel, int op) {
        // 获取 Channel 的文件描述符
        int fd = channel->Fd();
        // 构造 epoll_event 结构体
        struct epoll_event ev;
        ev.data.fd = fd;
        ev.events = channel->Events();
        // 调用 epoll_ctl 函数进行操作
        int ret = epoll_ctl(_epoll_fd, op, fd, &ev);
        if (ret < 0) {
            ERR_LOG("EPOLLCTL FAILED!");
        }
    }

    // 检查指定的 Channel 是否已经在 _channel_map 中，即是否已经添加了事件监控
    bool _HasRegisteredChannel(Channel* channel) {
        // 在 _channel_map 中查找指定文件描述符对应的 Channel
        auto it = _channel_map.find(channel->Fd());
        if (it == _channel_map.end()) {
            return false;
        }
        return true;
    }

public:
    // 构造函数，创建 epoll 实例
    Poller() {
        _epoll_fd = epoll_create(MAX_EPOLLEVENTS);
        if (_epoll_fd < 0) {
            ERR_LOG("EPOLL CREATE FAILED!!");
            abort();
        }
    }

    // 添加或修改指定 Channel 的事件监听状态
    void UpdateEvent(Channel* channel) {
        // 检查 Channel 是否已经注册
        bool ret = _HasRegisteredChannel(channel);
        if (!ret) {
            // 未注册则添加到 _channel_map 中，并调用 _UpdateEpollEvent 函数添加事件监听
            _channel_map.insert(std::make_pair(channel->Fd(), channel));
            _UpdateEpollEvent(channel, EPOLL_CTL_ADD);
        } else {
            // 已注册则调用 _UpdateEpollEvent 函数修改事件监听
            _UpdateEpollEvent(channel, EPOLL_CTL_MOD);
        }
    }

    // 移除指定 Channel 的事件监听
    void RemoveEvent(Channel* channel) {
        // 在 _channel_map 中查找指定文件描述符对应的 Channel
        auto it = _channel_map.find(channel->Fd());
        if (it != _channel_map.end()) {
            // 找到则从 _channel_map 中移除
            _channel_map.erase(it);
        }
        // 调用 _UpdateEpollEvent 函数移除事件监听
        _UpdateEpollEvent(channel, EPOLL_CTL_DEL);
    }

    // 进行 epoll 事件监听，将活跃的 Channel 指针添加到 active 向量中
    void Poll(std::vector<Channel*>* active) {
        // 调用 epoll_wait 函数进行事件监听，-1 表示无限期等待
        int nfds = epoll_wait(_epoll_fd, _epoll_events, MAX_EPOLLEVENTS, -1);
        if (nfds < 0) {
            if (errno == EINTR) {
                // 被信号中断，直接返回
                return;
            }
            // 发生其他错误，记录错误日志并终止程序
            ERR_LOG("EPOLL WAIT ERROR:%s\n", strerror(errno));
            abort();
        }
        // 遍历所有活跃的事件
        for (int i = 0; i < nfds; i++) {
            // 在 _channel_map 中查找对应的 Channel
            auto it = _channel_map.find(_epoll_events[i].data.fd);
            assert(it != _channel_map.end());
            // 设置 Channel 的实际就绪事件
            it->second->SetREvents(_epoll_events[i].events);
            // 将活跃的 Channel 指针添加到 active 中
            active->push_back(it->second);
        }
    }
};

using TaskFunc = std::function<void()>;
using ReleaseFunc = std::function<void()>;
class TimerTask{
    private:
        uint64_t _id;       // 定时器任务对象ID
        uint32_t _timeout;  //定时任务的超时时间
        uint32_t _delay;    //定时任务的延时时间
        bool _canceled;     // false-表示没有被取消， true-表示被取消
        TaskFunc _task_cb;  //定时器对象要执行的定时任务
        ReleaseFunc _release; //用于删除TimerWheel中保存的定时器对象信息
    public:
        TimerTask(uint64_t id, uint32_t delay, const TaskFunc &cb): 
            _id(id), _timeout(delay), _task_cb(cb), _canceled(false) {}
        ~TimerTask() { 
            if (_canceled == false) _task_cb(); 
            _release(); 
        }
        void Cancel() { _canceled = true; } // 取消定时任务
        void SetRelease(const ReleaseFunc &cb) { _release = cb; } // 设置回调
        uint32_t TimeOut() { return _timeout; } // 返回定时时间
        uint32_t DelayTime() { return _delay; } // 返回延时时间
        void SetDelay(uint32_t delay) { _delay = delay; }
};

// 时分秒三级时间轮类
class TimerWheel {
    using TaskFunc = std::function<void()>;
    using WeakTask = std::weak_ptr<TimerTask>;
    using PtrTask = std::shared_ptr<TimerTask>;

private:
    static constexpr int _SECOND_CAPACITY = 60;
    static constexpr int _MINUTE_CAPACITY = 60;
    static constexpr int _HOUR_CAPACITY = 12;

    int _second_tick = 0;
    std::vector<std::vector<PtrTask>> _second_wheel;

    int _minute_tick = 0;
    std::vector<std::vector<PtrTask>> _minute_wheel;

    int _hour_tick = 0;
    std::vector<std::vector<PtrTask>> _hour_wheel;

    std::unordered_map<uint64_t, WeakTask> _timers;

    class EventLoop* _loop;
    int _timer_fd;
    std::unique_ptr<Channel> _timer_channel;

    // 移除定时器任务
    void RemoveTimer(uint64_t id) {
        auto it = _timers.find(id);
        if (it != _timers.end()) {
            _timers.erase(it);
        }
    }

    // 创建定时器文件描述符
    static int CreateTimerFd() {
        int timer_fd = timerfd_create(CLOCK_MONOTONIC, 0);
        if (timer_fd < 0) {
            ERR_LOG("TIMERFD CREATE FAILED!");
            std::abort();
        }
        struct itimerspec itime;
        itime.it_value.tv_sec = 1;
        itime.it_value.tv_nsec = 0;
        itime.it_interval.tv_sec = 1;
        itime.it_interval.tv_nsec = 0;
        timerfd_settime(timer_fd, 0, &itime, nullptr);
        return timer_fd;
    }

    // 读取定时器文件描述符
    int ReadTimerFd() {
        uint64_t times;
        int ret = read(_timer_fd, &times, 8);
        if (ret < 0) {
            std::cerr << "READ TIMEFD FAILED!" << std::endl;
            std::abort();
        }
        return times;
    }

    // 推进秒级时间轮
    void AdvanceSecondWheel() {
        _second_tick = (_second_tick + 1) % _SECOND_CAPACITY;
        if (_second_tick == 0) {
            AdvanceMinuteWheel();
        }
        // 执行秒级时间轮当前槽位的任务
        _second_wheel[_second_tick].clear();
    }

    // 重新映射任务到合适的时间轮
    void RemapTask(PtrTask task) {
        int remaining_delay = task->DelayTime();
        if (remaining_delay < 60) {
            // 剩余时间小于 60 秒，放入秒级时间轮
            _second_wheel[(remaining_delay + _second_tick) % _SECOND_CAPACITY].push_back(task);
        } else if (remaining_delay < 3600) {
            // 剩余时间小于 3600 秒，放入分钟级时间轮
            int minutes = remaining_delay / 60;
            _minute_wheel[(_minute_tick + minutes) % _MINUTE_CAPACITY].push_back(task);
        } else {
            // 剩余时间大于等于 3600 秒，放入小时级时间轮
            int hours = remaining_delay / 3600;
            _hour_wheel[(_hour_tick + hours) % _HOUR_CAPACITY].push_back(task);
        }
    }

    // 推进分钟级时间轮
    void AdvanceMinuteWheel() {
        _minute_tick = (_minute_tick + 1) % _MINUTE_CAPACITY;
        if (_minute_tick == 0) {
            AdvanceHourWheel();
        }
        // 处理分钟级时间轮当前槽位的任务
        for (auto& task : _minute_wheel[_minute_tick]) {
            int remaining_delay = task->DelayTime() - 60;
            task->SetDelay(remaining_delay); // 更新任务的延迟时间
            RemapTask(task);
        }
        _minute_wheel[_minute_tick].clear();
    }

    // 推进小时级时间轮
    void AdvanceHourWheel() {
        _hour_tick = (_hour_tick + 1) % _HOUR_CAPACITY;
        // 处理小时级时间轮当前槽位的任务
        for (auto& task : _hour_wheel[_hour_tick]) {
            int remaining_delay = task->DelayTime() - 3600;
            task->SetDelay(remaining_delay); // 更新任务的延迟时间
            RemapTask(task);
        }
        _hour_wheel[_hour_tick].clear();
    }

    // 处理定时器超时事件
    void OnTime() {
        int times = ReadTimerFd();
        for (int i = 0; i < times; i++) {
            AdvanceSecondWheel();
        }
    }

    // 在事件循环中添加定时器任务
    void TimerAddInLoop(uint64_t id, uint32_t delay, const TaskFunc& cb) {
        PtrTask pt = std::make_shared<TimerTask>(id, delay, cb);
        pt->SetRelease([this, id]() { RemoveTimer(id); });

        if (delay < 60) {
            // 延迟小于 60 秒，放入秒级时间轮
            _second_wheel[(_second_tick + delay) % _SECOND_CAPACITY].push_back(pt);
        } else if (delay < 3600) {
            // 延迟小于 3600 秒，放入分钟级时间轮
            int minutes = delay / 60;
            _minute_wheel[(_minute_tick + minutes) % _MINUTE_CAPACITY].push_back(pt);
        } else {
            // 延迟大于等于 3600 秒，放入小时级时间轮
            int hours = delay / 3600;
            _hour_wheel[(_hour_tick + hours) % _HOUR_CAPACITY].push_back(pt);
        }
        _timers[id] = pt;
    }

    // 在事件循环中刷新定时器任务
    void TimerRefreshInLoop(uint64_t id) {
        auto it = _timers.find(id);
        if (it == _timers.end()) {
            return;
        }
        PtrTask pt = it->second.lock();
        if (!pt) {
            return;
        }
        int delay = pt->TimeOut();
        if (delay < 60) {
            // 延迟小于 60 秒，放入秒级时间轮
            _second_wheel[(_second_tick + delay) % _SECOND_CAPACITY].push_back(pt);
        } else if (delay < 3600) {
            // 延迟小于 3600 秒，放入分钟级时间轮
            int minutes = delay / 60;
            _minute_wheel[(_minute_tick + minutes) % _MINUTE_CAPACITY].push_back(pt);
        } else {
            // 延迟大于等于 3600 秒，放入小时级时间轮
            int hours = delay / 3600;
            _hour_wheel[(_hour_tick + hours) % _HOUR_CAPACITY].push_back(pt);
        }
    }

    // 在事件循环中取消定时器任务
    void TimerCancelInLoop(uint64_t id) {
        auto it = _timers.find(id);
        if (it == _timers.end()) {
            return;
        }
        PtrTask pt = it->second.lock();
        if (pt) {
            pt->Cancel();
        }
    }

public:
    TimerWheel(class EventLoop* loop)
        : _second_wheel(_SECOND_CAPACITY), _minute_wheel(_MINUTE_CAPACITY), _hour_wheel(_HOUR_CAPACITY),
          _loop(loop), _timer_fd(CreateTimerFd()),
          _timer_channel(new Channel(loop, _timer_fd)) {
        _timer_channel->SetReadCallback([this]() { OnTime(); });
        _timer_channel->EnableRead();
    }

    // 添加定时器任务
    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc& cb);

    // 刷新定时器任务
    void TimerRefresh(uint64_t id);

    // 取消定时器任务
    void TimerCancel(uint64_t id);

    // 检查定时器任务是否存在
    bool HasTimer(uint64_t id) {
        auto it = _timers.find(id);
        return it != _timers.end();
    }
};

class EventLoop {
    private:
        using Functor = std::function<void()>;
        std::thread::id _thread_id;//线程ID
        int _event_fd;//eventfd唤醒IO事件监控有可能导致的阻塞
        std::unique_ptr<Channel> _event_channel;
        Poller _poller;//进行所有描述符的事件监控
        std::vector<Functor> _tasks;//任务池
        std::mutex _mutex;//实现任务池操作的线程安全
        TimerWheel _timer_wheel;//定时器模块
    public:
        //执行任务池中的所有任务
        void RunAllTask() {
            std::vector<Functor> functor;
            {
                std::unique_lock<std::mutex> _lock(_mutex);
                _tasks.swap(functor);
            }
            for (auto &f : functor) {
                f();
            }
            return ;
        }
        static int CreateEventFd() {
            int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
            if (efd < 0) {
                ERR_LOG("CREATE EVENTFD FAILED!!");
                abort();//让程序异常退出
            }
            return efd;
        }
        void ReadEventfd() {
            uint64_t res = 0;
            int ret = read(_event_fd, &res, sizeof(res));
            if (ret < 0) {
                //EINTR -- 被信号打断；   EAGAIN -- 表示无数据可读
                if (errno == EINTR || errno == EAGAIN) {
                    return;
                }
                ERR_LOG("READ EVENTFD FAILED!");
                abort();
            }
            return ;
        }
        void WeakUpEventFd() {
            uint64_t val = 1;
            int ret = write(_event_fd, &val, sizeof(val));
            if (ret < 0) {
                if (errno == EINTR) {
                    return;
                }
                ERR_LOG("READ EVENTFD FAILED!");
                abort();
            }
            return ;
        }
    public:
        EventLoop():_thread_id(std::this_thread::get_id()), 
                    _event_fd(CreateEventFd()), 
                    _event_channel(new Channel(this, _event_fd)),
                    _timer_wheel(this) {
            //给eventfd添加可读事件回调函数，读取eventfd事件通知次数
            _event_channel->SetReadCallback(std::bind(&EventLoop::ReadEventfd, this));
            //启动eventfd的读事件监控
            _event_channel->EnableRead();
        }
        //三步走--事件监控-》就绪事件处理-》执行任务
        void Start() {
            while(1) {
                //1. 事件监控， 
                std::vector<Channel *> actives;
                _poller.Poll(&actives);
                //2. 事件处理。 
                for (auto &channel : actives) {
                    channel->HandleEvent();
                }
                //3. 执行任务
                RunAllTask();
            }
        }
        //用于判断当前线程是否是EventLoop对应的线程；
        bool IsInLoop() {
            return (_thread_id == std::this_thread::get_id());
        }
        void AssertInLoop() {
            assert(_thread_id == std::this_thread::get_id());
        }
        //判断将要执行的任务是否处于当前线程中，如果是则执行，不是则压入队列。
        void RunInLoop(const Functor &cb) {
            if (IsInLoop()) {
                return cb();
            }
            return QueueInLoop(cb);
        }
        //将操作压入任务池
        void QueueInLoop(const Functor &cb) {
            {
                std::unique_lock<std::mutex> _lock(_mutex);
                _tasks.push_back(cb);
            }
            //唤醒有可能因为没有事件就绪，而导致的epoll阻塞；
            //其实就是给eventfd写入一个数据，eventfd就会触发可读事件
            WeakUpEventFd();
        }
        //添加/修改描述符的事件监控
        void UpdateEvent(Channel *channel) { return _poller.UpdateEvent(channel); }
        //移除描述符的监控
        void RemoveEvent(Channel *channel) { return _poller.RemoveEvent(channel); }
        void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb) { return _timer_wheel.TimerAdd(id, delay, cb); }
        void TimerRefresh(uint64_t id) { return _timer_wheel.TimerRefresh(id); }
        void TimerCancel(uint64_t id) { return _timer_wheel.TimerCancel(id); }
        bool HasTimer(uint64_t id) { return _timer_wheel.HasTimer(id); }
};
class LoopThread {
    private:
        /*用于实现_loop获取的同步关系，避免线程创建了，但是_loop还没有实例化之前去获取_loop*/
        std::mutex _mutex;          // 互斥锁
        std::condition_variable _cond;   // 条件变量
        EventLoop *_loop;       // EventLoop指针变量，这个对象需要在线程内实例化
        std::thread _thread;    // EventLoop对应的线程
    private:
        /*实例化 EventLoop 对象，唤醒_cond上有可能阻塞的线程，并且开始运行EventLoop模块的功能*/
        void ThreadEntry() {
            EventLoop loop;
            {
                std::unique_lock<std::mutex> lock(_mutex);//加锁
                _loop = &loop;
                _cond.notify_all();
            }
            loop.Start();
        }
    public:
        /*创建线程，设定线程入口函数*/
        LoopThread():_loop(NULL), _thread(std::thread(&LoopThread::ThreadEntry, this)) {}
        /*返回当前线程关联的EventLoop对象指针*/
        EventLoop *GetLoop() {
            EventLoop *loop = NULL;
            {
                std::unique_lock<std::mutex> lock(_mutex);//加锁
                _cond.wait(lock, [&](){ return _loop != NULL; });//loop为NULL就一直阻塞
                loop = _loop;
            }
            return loop;
        }
};

class LoopThreadPool {
    private:
        int _thread_count;
        int _next_idx;
        EventLoop *_baseloop;
        std::vector<LoopThread*> _threads;
        std::vector<EventLoop *> _loops;
    public:
        LoopThreadPool(EventLoop *baseloop):_thread_count(0), _next_idx(0), _baseloop(baseloop) {}
        void SetThreadCount(int count) { _thread_count = count; }
        void Create() {
            if (_thread_count > 0) {
                _threads.resize(_thread_count);
                _loops.resize(_thread_count);
                for (int i = 0; i < _thread_count; i++) {
                    _threads[i] = new LoopThread();
                    _loops[i] = _threads[i]->GetLoop();
                }
            }
            return ;
        }
        EventLoop *NextLoop() {
            if (_thread_count == 0) {
                return _baseloop;
            }
            _next_idx = (_next_idx + 1) % _thread_count;
            return _loops[_next_idx];
        }
};


class Any{
    private:
        class holder {
            public:
                virtual ~holder() {}
                virtual const std::type_info& type() = 0;
                virtual holder *clone() = 0;
        };
        template<class T>
        class placeholder: public holder {
            public:
                placeholder(const T &val): _val(val) {}
                // 获取子类对象保存的数据类型
                virtual const std::type_info& type() { return typeid(T); }
                // 针对当前的对象自身，克隆出一个新的子类对象
                virtual holder *clone() { return new placeholder(_val); }
            public:
                T _val;
        };
        holder *_content;
    public:
        Any():_content(NULL) {}
        template<class T>
        Any(const T &val):_content(new placeholder<T>(val)) {}
        Any(const Any &other):_content(other._content ? other._content->clone() : NULL) {}
        ~Any() { delete _content; }

        Any &swap(Any &other) {
            std::swap(_content, other._content);
            return *this;
        }

        // 返回子类对象保存的数据的指针
        template<class T>
        T *get() {
            //想要获取的数据类型，必须和保存的数据类型一致
            assert(typeid(T) == _content->type());
            return &((placeholder<T>*)_content)->_val;
        }
        //赋值运算符的重载函数
        template<class T>
        Any& operator=(const T &val) {
            //为val构造一个临时的通用容器，然后与当前容器自身进行指针交换，临时对象释放的时候，原先保存的数据也就被释放
            Any(val).swap(*this);
            return *this;
        }
        Any& operator=(const Any &other) {
            Any(other).swap(*this);
            return *this;
        }
};

// 前向声明 Connection 类
class Connection;

// 定义连接状态的枚举类型
// CONNECTING -- 连接建立成功，但处于待处理状态
// CONNECTED -- 连接建立完成，各项设置已完成，可以进行通信的状态
// DISCONNECTING -- 连接处于待关闭状态
// DISCONNECTED -- 连接关闭状态
typedef enum { DISCONNECTED, CONNECTING, CONNECTED, DISCONNECTING } ConnStatu;

// 使用智能指针管理 Connection 对象
using PtrConnection = std::shared_ptr<Connection>;

// Connection 类，用于管理网络连接，继承自 std::enable_shared_from_this 以便安全地获取自身的 shared_ptr
class Connection : public std::enable_shared_from_this<Connection> {
private:
    uint64_t _conn_id;  // 连接的唯一标识符，用于连接的管理和查找
    int _sockfd;        // 连接关联的文件描述符
    bool _enable_inactive_release;  // 连接是否启用非活跃销毁的判断标志，默认为 false
    EventLoop *_loop;   // 连接所关联的 EventLoop 对象，用于事件循环和任务调度
    ConnStatu _statu;   // 连接的当前状态
    Socket _socket;     // 套接字操作管理对象，负责与网络套接字的交互
    Channel _channel;   // 连接的事件管理对象，用于处理文件描述符的各种事件
    Buffer _in_buffer;  // 输入缓冲区，用于存放从套接字中读取到的数据
    Buffer _out_buffer; // 输出缓冲区，用于存放要发送给对端的数据
    Any _context;       // 请求的接收处理上下文，可用于存储和传递额外的信息

    // 定义各种回调函数类型，这些回调函数由服务器模块或组件使用者设置
    // ConnectedCallback -- 连接建立完成时的回调函数
    using ConnectedCallback = std::function<void(const PtrConnection&)>;
    // MessageCallback -- 接收到消息时的回调函数
    using MessageCallback = std::function<void(const PtrConnection&, Buffer *)>;
    // ClosedCallback -- 连接关闭时的回调函数
    using ClosedCallback = std::function<void(const PtrConnection&)>;
    // AnyEventCallback -- 任意事件触发时的回调函数
    using AnyEventCallback = std::function<void(const PtrConnection&)>;

    ConnectedCallback _connected_callback;  // 连接建立完成时的回调函数
    MessageCallback _message_callback;      // 接收到消息时的回调函数
    ClosedCallback _closed_callback;        // 连接关闭时的回调函数
    AnyEventCallback _event_callback;       // 任意事件触发时的回调函数

    // 组件内的连接关闭回调函数，用于在服务器组件内移除连接信息
    ClosedCallback _server_closed_callback;

private:
    // 处理文件描述符可读事件的回调函数
    // 当文件描述符可读时，从套接字读取数据到输入缓冲区，并调用消息处理回调函数
    void HandleRead() {
        // 1. 从套接字接收数据到缓冲区
        char buf[65536];
        ssize_t ret = _socket.NonBlockRecv(buf, 65535);
        if (ret < 0) {
            // 接收数据出错，不能直接关闭连接，调用 ShutdownInLoop 处理
            return ShutdownInLoop();
        }
        // 将读取到的数据写入输入缓冲区，并更新写偏移
        _in_buffer.WriteAndPush(buf, ret);
        // 2. 如果输入缓冲区有可读数据，调用消息处理回调函数进行业务处理
        if (_in_buffer.ReadAbleSize() > 0) {
            // 使用 shared_from_this 获取当前对象的 shared_ptr，确保对象在回调期间不会被意外销毁
            return _message_callback(shared_from_this(), &_in_buffer);
        }
    }

    // 处理文件描述符可写事件的回调函数
    // 当文件描述符可写时，将输出缓冲区中的数据发送出去
    void HandleWrite() {
        // 从输出缓冲区读取数据并发送
        ssize_t ret = _socket.NonBlockSend(_out_buffer.ReadPosition(), _out_buffer.ReadAbleSize());
        if (ret < 0) {
            // 发送数据出错，先处理输入缓冲区中的数据，然后释放连接
            if (_in_buffer.ReadAbleSize() > 0) {
                _message_callback(shared_from_this(), &_in_buffer);
            }
            return Release();
        }
        // 更新输出缓冲区的读偏移
        _out_buffer.MoveReadOffset(ret);
        // 如果输出缓冲区没有待发送的数据，关闭写事件监控
        if (_out_buffer.ReadAbleSize() == 0) {
            _channel.DisableWrite();
            // 如果连接处于待关闭状态，释放连接
            if (_statu == DISCONNECTING) {
                return Release();
            }
        }
        return;
    }

    // 处理文件描述符挂断事件的回调函数
    // 当文件描述符触发挂断事件时，处理输入缓冲区中的数据，然后释放连接
    void HandleClose() {
        // 如果输入缓冲区有数据，调用消息处理回调函数处理
        if (_in_buffer.ReadAbleSize() > 0) {
            _message_callback(shared_from_this(), &_in_buffer);
        }
        return Release();
    }

    // 处理文件描述符出错事件的回调函数
    // 当文件描述符触发出错事件时，调用 HandleClose 处理
    void HandleError() {
        return HandleClose();
    }

    // 处理文件描述符任意事件的回调函数
    // 当文件描述符触发任意事件时，刷新连接的活跃度（如果启用了非活跃销毁），并调用任意事件回调函数
    void HandleEvent() {
        if (_enable_inactive_release == true) {
            // 刷新连接的活跃度，延迟定时销毁任务
            _loop->TimerRefresh(_conn_id);
        }
        if (_event_callback) {
            // 调用任意事件回调函数
            _event_callback(shared_from_this());
        }
    }

    // 连接建立完成后，在 EventLoop 中执行的初始化操作
    // 修改连接状态，启动读事件监控，并调用连接建立完成的回调函数
    void EstablishedInLoop() {
        // 确保当前连接状态为 CONNECTING
        assert(_statu == CONNECTING);
        // 修改连接状态为 CONNECTED
        _statu = CONNECTED;
        // 启动读事件监控
        _channel.EnableRead();
        // 如果设置了连接建立完成的回调函数，调用该函数
        if (_connected_callback) {
            _connected_callback(shared_from_this());
        }
    }

    // 实际释放连接资源的函数
    // 修改连接状态，移除事件监控，关闭文件描述符，取消定时销毁任务，调用关闭回调函数
    void ReleaseInLoop() {
        // 1. 修改连接状态为 DISCONNECTED
        _statu = DISCONNECTED;
        // 2. 移除连接的事件监控
        _channel.Remove();
        // 3. 关闭文件描述符
        _socket.Close();
        // 4. 如果定时器队列中存在定时销毁任务，取消该任务
        if (_loop->HasTimer(_conn_id)) {
            CancelInactiveReleaseInLoop();
        }
        // 5. 调用用户设置的关闭回调函数
        if (_closed_callback) {
            _closed_callback(shared_from_this());
        }
        // 移除服务器内部管理的连接信息
        if (_server_closed_callback) {
            _server_closed_callback(shared_from_this());
        }
    }

    // 发送数据的内部函数
    // 将数据放入输出缓冲区，启动写事件监控
    void SendInLoop(Buffer &buf) {
        // 如果连接已经关闭，直接返回
        if (_statu == DISCONNECTED) {
            return;
        }
        // 将数据写入输出缓冲区
        _out_buffer.WriteBufferAndPush(buf);
        // 如果写事件未启用，启动写事件监控
        if (_channel.WriteAble() == false) {
            _channel.EnableWrite();
        }
    }

    // 关闭连接的内部函数
    // 设置连接为待关闭状态，处理输入缓冲区中的数据，根据输出缓冲区的情况决定是否释放连接
    void ShutdownInLoop() {
        // 设置连接状态为 DISCONNECTING
        _statu = DISCONNECTING;
        // 如果输入缓冲区有数据，调用消息处理回调函数处理
        if (_in_buffer.ReadAbleSize() > 0) {
            if (_message_callback) {
                _message_callback(shared_from_this(), &_in_buffer);
            }
        }
        // 如果输出缓冲区有数据，启动写事件监控
        if (_out_buffer.ReadAbleSize() > 0) {
            if (_channel.WriteAble() == false) {
                _channel.EnableWrite();
            }
        }
        // 如果输出缓冲区没有数据，释放连接
        if (_out_buffer.ReadAbleSize() == 0) {
            Release();
        }
    }

    // 启用非活跃连接超时释放规则的内部函数
    // 设置启用标志，根据定时任务的存在情况进行刷新或新增
    void EnableInactiveReleaseInLoop(int sec) {
        // 1. 设置启用非活跃销毁的标志为 true
        _enable_inactive_release = true;
        // 2. 如果定时销毁任务已经存在，刷新该任务
        if (_loop->HasTimer(_conn_id)) {
            return _loop->TimerRefresh(_conn_id);
        }
        // 3. 如果定时销毁任务不存在，新增定时销毁任务
        _loop->TimerAdd(_conn_id, sec, std::bind(&Connection::Release, this));
    }

    // 取消非活跃连接超时释放规则的内部函数
    // 禁用标志，取消定时销毁任务
    void CancelInactiveReleaseInLoop() {
        // 禁用非活跃销毁标志
        _enable_inactive_release = false;
        // 如果定时销毁任务存在，取消该任务
        if (_loop->HasTimer(_conn_id)) {
            _loop->TimerCancel(_conn_id);
        }
    }

    // 升级连接协议的内部函数
    // 重置上下文和回调函数
    void UpgradeInLoop(const Any &context, 
                       const ConnectedCallback &conn, 
                       const MessageCallback &msg, 
                       const ClosedCallback &closed, 
                       const AnyEventCallback &event) {
        // 更新上下文
        _context = context;
        // 更新连接建立完成的回调函数
        _connected_callback = conn;
        // 更新消息处理回调函数
        _message_callback = msg;
        // 更新连接关闭的回调函数
        _closed_callback = closed;
        // 更新任意事件的回调函数
        _event_callback = event;
    }

public:
    // 构造函数，初始化连接对象
    Connection(EventLoop *loop, uint64_t conn_id, int sockfd)
        : _conn_id(conn_id), _sockfd(sockfd),
          _enable_inactive_release(false), _loop(loop), _statu(CONNECTING), _socket(_sockfd),
          _channel(loop, _sockfd) {
        // 设置 Channel 的各种回调函数
        _channel.SetCloseCallback(std::bind(&Connection::HandleClose, this));
        _channel.SetEventCallback(std::bind(&Connection::HandleEvent, this));
        _channel.SetReadCallback(std::bind(&Connection::HandleRead, this));
        _channel.SetWriteCallback(std::bind(&Connection::HandleWrite, this));
        _channel.SetErrorCallback(std::bind(&Connection::HandleError, this));
    }

    // 析构函数，输出连接释放的调试信息
    ~Connection() {
        DBG_LOG("RELEASE CONNECTION:%p", this);
    }

    // 获取连接关联的文件描述符
    int Fd() {
        return _sockfd;
    }

    // 获取连接的唯一标识符
    int Id() {
        return _conn_id;
    }

    // 判断连接是否处于 CONNECTED 状态
    bool Connected() {
        return (_statu == CONNECTED);
    }

    // 设置连接的上下文信息
    void SetContext(const Any &context) {
        _context = context;
    }

    // 获取连接的上下文信息指针
    Any *GetContext() {
        return &_context;
    }

    // 设置连接建立完成的回调函数
    void SetConnectedCallback(const ConnectedCallback& cb) {
        _connected_callback = cb;
    }

    // 设置消息处理的回调函数
    void SetMessageCallback(const MessageCallback& cb) {
        _message_callback = cb;
    }

    // 设置连接关闭的回调函数
    void SetClosedCallback(const ClosedCallback& cb) {
        _closed_callback = cb;
    }

    // 设置任意事件的回调函数
    void SetAnyEventCallback(const AnyEventCallback& cb) {
        _event_callback = cb;
    }

    // 设置服务器内部的连接关闭回调函数
    void SetSrvClosedCallback(const ClosedCallback& cb) {
        _server_closed_callback = cb;
    }

    // 连接建立就绪后，在 EventLoop 中执行初始化操作
    void Established() {
        _loop->RunInLoop(std::bind(&Connection::EstablishedInLoop, this));
    }

    // 发送数据的公共接口
    // 将数据放入缓冲区，在 EventLoop 中执行发送操作
    void Send(const char *data, size_t len) {
        // 创建临时缓冲区，避免传入的 data 可能是临时空间
        Buffer buf;
        buf.WriteAndPush(data, len);
        // 在 EventLoop 中执行发送操作
        _loop->RunInLoop(std::bind(&Connection::SendInLoop, this, std::move(buf)));
    }

    // 关闭连接的公共接口
    // 在 EventLoop 中执行关闭操作
    void Shutdown() {
        _loop->RunInLoop(std::bind(&Connection::ShutdownInLoop, this));
    }

    // 释放连接资源的公共接口
    // 将释放操作放入 EventLoop 的任务队列中执行
    void Release() {
        _loop->QueueInLoop(std::bind(&Connection::ReleaseInLoop, this));
    }

    // 启用非活跃连接超时释放规则的公共接口
    // 在 EventLoop 中执行启用操作
    void EnableInactiveRelease(int sec) {
        _loop->RunInLoop(std::bind(&Connection::EnableInactiveReleaseInLoop, this, sec));
    }

    // 取消非活跃连接超时释放规则的公共接口
    // 在 EventLoop 中执行取消操作
    void CancelInactiveRelease() {
        _loop->RunInLoop(std::bind(&Connection::CancelInactiveReleaseInLoop, this));
    }

    // 升级连接协议的公共接口
    // 在 EventLoop 线程中立即执行升级操作
    void Upgrade(const Any &context, const ConnectedCallback &conn, const MessageCallback &msg, 
                 const ClosedCallback &closed, const AnyEventCallback &event) {
        // 确保在 EventLoop 线程中执行
        _loop->AssertInLoop();
        // 在 EventLoop 中执行升级操作
        _loop->RunInLoop(std::bind(&Connection::UpgradeInLoop, this, context, conn, msg, closed, event));
    }
};
class Acceptor {
    private:
        Socket _socket;//用于创建监听套接字
        EventLoop *_loop; //用于对监听套接字进行事件监控
        Channel _channel; //用于对监听套接字进行事件管理

        using AcceptCallback = std::function<void(int)>;
        AcceptCallback _accept_callback;
    private:
        /*监听套接字的读事件回调处理函数---获取新连接，调用_accept_callback函数进行新连接处理*/
        void HandleRead() {
            int newfd = _socket.Accept();
            if (newfd < 0) {
                return ;
            }
            if (_accept_callback) _accept_callback(newfd);
        }
        int CreateServer(int port) {
            bool ret = _socket.CreateServer(port);
            assert(ret == true);
            return _socket.Fd();
        }
    public:
        /*不能将启动读事件监控，放到构造函数中，必须在设置回调函数后，再去启动*/
        /*否则有可能造成启动监控后，立即有事件，处理的时候，回调函数还没设置：新连接得不到处理，且资源泄漏*/
        Acceptor(EventLoop *loop, int port): _socket(CreateServer(port)), _loop(loop), 
            _channel(loop, _socket.Fd()) {
            _channel.SetReadCallback(std::bind(&Acceptor::HandleRead, this));
        }
        void SetAcceptCallback(const AcceptCallback &cb) { _accept_callback = cb; }
        void Listen() { _channel.EnableRead(); }
};

class TcpServer {
    private:
        uint64_t _next_id;      //这是一个自动增长的连接ID，
        int _port;
        int _timeout;           //这是非活跃连接的统计时间---多长时间无通信就是非活跃连接
        bool _enable_inactive_release;//是否启动了非活跃连接超时销毁的判断标志
        EventLoop _baseloop;    //这是主线程的EventLoop对象，负责监听事件的处理
        Acceptor _acceptor;    //这是监听套接字的管理对象
        LoopThreadPool _pool;   //这是从属EventLoop线程池
        std::unordered_map<uint64_t, PtrConnection> _conns;//保存管理所有连接对应的shared_ptr对象

        using ConnectedCallback = std::function<void(const PtrConnection&)>;
        using MessageCallback = std::function<void(const PtrConnection&, Buffer *)>;
        using ClosedCallback = std::function<void(const PtrConnection&)>;
        using AnyEventCallback = std::function<void(const PtrConnection&)>;
        using Functor = std::function<void()>;
        ConnectedCallback _connected_callback;
        MessageCallback _message_callback;
        ClosedCallback _closed_callback;
        AnyEventCallback _event_callback;
    private:
        void RunAfterInLoop(const Functor &task, int delay) {
            _next_id++;
            _baseloop.TimerAdd(_next_id, delay, task);
        }
        //为新连接构造一个Connection进行管理
        void NewConnection(int fd) {
            _next_id++;
            PtrConnection conn(new Connection(_pool.NextLoop(), _next_id, fd));
            conn->SetMessageCallback(_message_callback);
            conn->SetClosedCallback(_closed_callback);
            conn->SetConnectedCallback(_connected_callback);
            conn->SetAnyEventCallback(_event_callback);
            conn->SetSrvClosedCallback(std::bind(&TcpServer::RemoveConnection, this, std::placeholders::_1));
            if (_enable_inactive_release) conn->EnableInactiveRelease(_timeout);//启动非活跃超时销毁
            conn->Established();//就绪初始化
            _conns.insert(std::make_pair(_next_id, conn));
        }
        void RemoveConnectionInLoop(const PtrConnection &conn) {
            int id = conn->Id();
            auto it = _conns.find(id);
            if (it != _conns.end()) {
                _conns.erase(it);
            }
        }
        //从管理Connection的_conns中移除连接信息
        void RemoveConnection(const PtrConnection &conn) {
            _baseloop.RunInLoop(std::bind(&TcpServer::RemoveConnectionInLoop, this, conn));
        }
    public:
        TcpServer(int port):
            _port(port), 
            _next_id(0), 
            _enable_inactive_release(false), 
            _acceptor(&_baseloop, port),
            _pool(&_baseloop) {
            _acceptor.SetAcceptCallback(std::bind(&TcpServer::NewConnection, this, std::placeholders::_1));
            _acceptor.Listen();//将监听套接字挂到baseloop上
        }
        void SetThreadCount(int count) { return _pool.SetThreadCount(count); }
        void SetConnectedCallback(const ConnectedCallback&cb) { _connected_callback = cb; }
        void SetMessageCallback(const MessageCallback&cb) { _message_callback = cb; }
        void SetClosedCallback(const ClosedCallback&cb) { _closed_callback = cb; }
        void SetAnyEventCallback(const AnyEventCallback&cb) { _event_callback = cb; }
        void EnableInactiveRelease(int timeout) { _timeout = timeout; _enable_inactive_release = true; }
        //用于添加一个定时任务
        void RunAfter(const Functor &task, int delay) {
            _baseloop.RunInLoop(std::bind(&TcpServer::RunAfterInLoop, this, task, delay));
        }
        void Start() { _pool.Create();  _baseloop.Start(); }
};


void Channel::Remove() { return _loop->RemoveEvent(this); }
void Channel::Update() { return _loop->UpdateEvent(this); }
void TimerWheel::TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb) {
    _loop->RunInLoop(std::bind(&TimerWheel::TimerAddInLoop, this, id, delay, cb));
}
//刷新/延迟定时任务
void TimerWheel::TimerRefresh(uint64_t id) {
    _loop->RunInLoop(std::bind(&TimerWheel::TimerRefreshInLoop, this, id));
}
void TimerWheel::TimerCancel(uint64_t id) {
    _loop->RunInLoop(std::bind(&TimerWheel::TimerCancelInLoop, this, id));
}


class NetWork {
    public:
        NetWork() {
            DBG_LOG("SIGPIPE INIT");
            signal(SIGPIPE, SIG_IGN);
        }
};
static NetWork nw;



#endif